package cn.itcast.service.impl;

import cn.itcast.dao.CourierDao;
import cn.itcast.domain.Courier;
import cn.itcast.domain.Standard;
import cn.itcast.service.CourierService;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.jpa.domain.Specification;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.persistence.criteria.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;


@Transactional
@Service
public class CourierServiceImpl implements CourierService {

    @Autowired
    private CourierDao courierDao;

    @Override
    public void save(Courier courier) {
        courierDao.save(courier);
     }

    @Override
    public Page<Courier> pageQuery(int page, int rows,Courier courier) {
        //构造一个specification条件接口对象,使用内部类方式创建
        Specification specification = new Specification<Courier>(){
            //重写其toPredicate方法达成为specification赋予条件的目的
            @Override
            //Root 用于获取属性字段，CriteriaQuery可以用于简单条件查询，CriteriaBuilder 用于构造复杂条件查询
            public Predicate toPredicate(Root<Courier> root, CriteriaQuery<?> query, CriteriaBuilder cb) {
                //创建集合逐个添加条件
                List<Predicate> list = new ArrayList<Predicate>();
                //简单查询
                //创建条件1:先做判断,如果获取的属性值不为空,才创建这个条件对象;属性名courierNum是否与模型驱动中取的值一致
                //StringUtils要导commons.lang3包下的
                if(StringUtils.isNotBlank(courier.getCourierNum())){
                    Predicate p1 = cb.equal(root.get("courierNum").as(String.class), courier.getCourierNum());
                    list.add(p1);
                }
                //创建条件2:所属单位
                if(StringUtils.isNotBlank(courier.getCompany())){
                    Predicate p2 = cb.like(root.get("company").as(String.class), "%"+courier.getCompany()+"%");
                    list.add(p2);
                }
                //创建条件3:取件员类型
                if(StringUtils.isNotBlank(courier.getType())){
                    Predicate p3 = cb.equal(root.get("type").as(String.class), courier.getType());
                    list.add(p3);
                }
                //复杂查询条件:
                //创建条件4:收派标准是否一致,利用root对象先创建join对象:对于前面的单层获取而言相当于双层获取
                //泛形是多:快递员,一:收派标准,而join方法给的是属性字段名和连接类型
                Join<Courier, Standard> standardJoin = root.join("standard", JoinType.INNER);
                if(courier.getStandard()!=null&&StringUtils.isNotBlank(courier.getStandard().getName())){
                    Predicate p4 = cb.like(standardJoin.get("name").as(String.class), "%"+courier.getStandard().getName()+"%");
                    list.add(p4);
                }

                return cb.and(list.toArray(new Predicate[0]));
            }
        };

        PageRequest pageable = PageRequest.of(page-1,rows);
        return courierDao.findAll(pageable);
    }

    @Override
    public void delBatch(int[] ids) {
        for(int id:ids){
            Optional<Courier> byId = courierDao.findById(id);
            Courier courier = byId.get();
            courier.setDeltag('1');
            }

    }

    @Override
    public void returnBatch(int[] ids) {
        for (int id:ids){
            courierDao.returnBatch(id,null);
        }
    }
}
